package com.laxia.util;

import com.laxia.constant.GlobalConstant;
import org.apache.commons.lang3.time.DateUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 有关日期处理的工具类。
 */
public class DateUtil extends DateUtils {

    public static final String DEFAULT_PATTERN = "yyyyMMdd";

    public static final String FULL_FORMAT_PATTERN = "yyyy-MM-dd HH:mm:ss";
    public static final String FULL_NUMBER_FORMAT_PATTERN = "yyyyMMddHHmmss";
    public static final String CH_FULL_FORMAT_PATTERN = "yyyy年MM月dd日 HH点mm分ss秒";


    /**
     * 获取当前日期时间戳10位
     *
     * @return 当前日期
     */
    public static int getCurrentTime() {
        return (int) (System.currentTimeMillis() / 1000);
    }

    /**
     * 获取指定时间的时间戳
     *
     * @param date
     * @return
     */
    public static int getDateTime(Date date) {
        return (int) (date.getTime() / 1000);
    }

    /**
     * 获取当前日期
     *
     * @return
     */
    public static Date getCurrentDate() {
        return new Date();
    }


    /**
     * 将日期转换为 <code>yyyyMMdd</code> 的字符串格式
     *
     * @param date 日期 @see Date
     * @return 格式化后的日期字符串
     */
    public static String formatDate(final Date date) {
        return formatDate(date, DEFAULT_PATTERN);
    }

    /**
     * 将日期转换为 <code>yyyy-MM-dd HH:mm:ss</code> 的字符串格式
     *
     * @param date 日期 @see Date
     * @return 格式化后的日期字符串
     */
    public static String formatFullDate(final Date date) {
        return formatDate(date, FULL_FORMAT_PATTERN);
    }

    /**
     * 将日期转换为 <code>yyyyMMddHHmmss</code> 的字符串格式
     *
     * @param date 日期 @see Date
     * @return 格式化后的日期字符串
     */
    public static String formatFullNumberDate(final Date date) {
        return formatDate(date, FULL_NUMBER_FORMAT_PATTERN);
    }

    /**
     * 将日期转换为指定的字符串格式
     *
     * @param date   日期 @see Date
     * @param format 日期格式
     * @return 格式化后的日期字符串，如果<code>date</code>为<code>null</code>或者 <code>format</code>为空，则返回<code>null</code>。
     */
    public static String formatDate(final Date date, String format) {
        if (null == date || StringUtil.isBlank(format)) {
            return null;
        }

        return new SimpleDateFormat(format).format(date);
    }

    /**
     * 将当前日期转换为指定的字符串格式
     *
     * @param format 日期格式
     * @return 格式化后的日期字符串
     */
    public static String formatDate(String format) {
        return formatDate(new Date(), format);
    }

    /**
     * 将<code>yyyyMMdd<code>格式的字符串转变为日期对象
     *
     * @param sDate 日期字符串
     * @return 日期
     */
    public static Date parseDate(String sDate) {
        return parseDate(sDate, DEFAULT_PATTERN, null);
    }

    /**
     * 将字符串转换撑日期对象
     *
     * @param sDate  日期字符串
     * @param format 日期格式 @see DateFormat
     * @return 日期对象 @see Date
     */
    public static Date parseDate(String sDate, String format) {
        return parseDate(sDate, format, null);
    }

    /**
     * 将字符串转换成日期对象
     *
     * @param sDate        日期字符串
     * @param format       日期格式 @see DateFormat
     * @param defaultValue 默认值
     * @return 日期对象，如果格式化失败则返回默认值<code>defaultValue</code>
     */
    public static Date parseDate(String sDate, String format, Date defaultValue) {
        if (StringUtil.isBlank(sDate) || StringUtil.isBlank(format)) {
            return defaultValue;
        }

        DateFormat formatter = new SimpleDateFormat(format);
        try {
            return formatter.parse(sDate);
        } catch (ParseException e) {
            return defaultValue;
        }

    }


    /**
     * @param type {Calendar.MINUTE, Calendar.DAY_OF_MONTH}
     */
    public static Date add(final Date date, int type, int value) {
        if (value == 0 || date == null) {
            return date;
        }
        Calendar cal = GregorianCalendar.getInstance();
        cal.setTime(date);
        cal.add(type, value);
        return cal.getTime();
    }


    /**
     * 获取时间间隔 秒
     */
    public static int minusSeconds(Date startTime, Date endTime) {
        long value = endTime.getTime() - startTime.getTime();
        return (int) (value / 1000);
    }

    /**
     * 获取当天的结束时间
     * yyyy-MM-dd 23:59:59
     */
    public static Date getCurrentDateEnd() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * 获取当天的开始时间
     *
     * @return yyyy-MM-dd 00:00:00
     */
    public static Date getCurrentDateStart() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取两个时间相隔天数
     */
    public static int diffDay(Date date1, Date date2) {
        return (int) ((date1.getTime() - date2.getTime()) / (1000 * 60 * 60 * 24));
    }


    /**
     * 获取两个时间相隔天数
     */
    public static int diffDayByTimes(Integer time1, Integer time2) {
        return (time1 - time2) / (60 * 60 * 24);
    }


    /**
     * 获取指定日期 0点时间
     */
    public static Date getDateStart(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取指定日期 结束时间
     */
    public static Date getDateEnd(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * @return yyyyMMdd
     */
    public static List<String> iteratorDay(Date startTime, Date endTime) {
        if (startTime == null || endTime == null || startTime.after(endTime)) {
            return Collections.emptyList();
        }

        startTime = getDateStart(startTime);
        endTime = getDateEnd(endTime);

        List<String> days = new ArrayList<>(32);
        do {
            days.add(formatDate(startTime));
            startTime = addDays(startTime, 1);
        } while (startTime.before(endTime));

        return days;
    }

    /**
     * 10位13位时间戳转Date
     *
     * @param timestamp            参数时间戳
     * @param simpleDateFormatType 时间戳类型（"yyyy-MM-dd HH:mm:ss"）
     * @return
     */
    public static Date numberDateFormatToDate(Integer timestamp, String simpleDateFormatType) {
        SimpleDateFormat sdf = new SimpleDateFormat(simpleDateFormatType);//要转换的时间格式
        Date date = null;
        try {
            if (timestamp.toString().length() == 13) {
                date = sdf.parse(sdf.format(Long.parseLong(timestamp.toString())));
            } else {
                date = sdf.parse(sdf.format(Long.parseLong(timestamp.toString()) * 1000));
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 10位13位时间戳转Date
     * 默认格式（"yyyy-MM-dd HH:mm:ss"）
     *
     * @param timestamp 参数时间戳
     * @return
     */
    public static Date numberDateFormatToDate(Integer timestamp) {
        try {
            return numberDateFormatToDate(timestamp, "yyyy-MM-dd HH:mm:ss");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String parseCreateTimeDesc(Integer createTime, String evn) {
        if (GlobalConstant.ENV_FOREIGN.equals(evn)) {
            int diff = DateUtil.getCurrentTime() - createTime;
            if (diff < 10 * 60) {
                return "just a moment";
            } else if (diff < 30 * 60) {
                return diff / 60 + "minutes ago";
            } else if (diff < 60 * 60) {
                return "half an hour ago";
            } else if (diff < 24 * 60 * 60) {
                return diff / (60 * 60) + "hours ago";
            } else if (diff < 1 * 24 * 60 * 60) {

                return "1 day ago";
            } else if (diff < 7 * 24 * 60 * 60) {

                return diff / (24 * 60 * 60) + "days ago";
            } else {
                return DateUtil.numberDateFormatToStr(createTime);
            }
        } else {
            int diff = DateUtil.getCurrentTime() - createTime;
            if (diff < 10 * 60) {
                return "刚刚";
            } else if (diff < 30 * 60) {
                return diff / 60 + "分钟前";
            } else if (diff < 60 * 60) {
                return "半小时前";
            } else if (diff < 24 * 60 * 60) {
                return diff / (60 * 60) + "小时前";
            } else if (diff < 1 * 24 * 60 * 60) {

                return "1 天前";
            } else if (diff < 7 * 24 * 60 * 60) {

                return diff / (24 * 60 * 60) + "天前";
            } else {
                return DateUtil.numberDateFormatToStr(createTime);
            }
        }

    }


    /**
     * 10位13位时间戳转Date
     * 默认格式（"yyyy-MM-dd HH:mm:ss"）
     *
     * @param timestamp 参数时间戳
     * @return
     */
    public static String numberDateFormatToStr(Integer timestamp) {
        try {
            return DateUtil.formatFullDate(numberDateFormatToDate(timestamp, "yyyy-MM-dd HH:mm:ss"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    public static void main(String[] args) {

        System.out.println(DateUtil.diffDayByTimes(DateUtil.getCurrentTime(), 1596189489));

    }


}
